home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Think Class Libraries / CAccordionPane 1.0 / parser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-30  |  5.7 KB  |  300 lines  |  [TEXT/KAHL]
  1. /******************************************************************************
  2.  Parser.c
  3.  
  4.     This is a small parse for the CAccodionPaneDemoDir. It parses and 
  5.     interperts a small pane structure language. It can build a structure of
  6.     arbitary complexity if you have the time to display it!
  7.     
  8.     The language definition is
  9.     
  10.         start = list
  11.         
  12.         list = ( vertical | horizontal ) subpanes '.'
  13.         
  14.         subpanes = subpane*
  15.         
  16.         subpane = fixed | elastic | list
  17.  
  18.         vertical = 'V' poriton
  19.  
  20.         horizontal = 'H' portion
  21.         
  22.         fixed = 'F' size
  23.         
  24.         elastic = 'E' protion        
  25.         
  26.         size = pixel count
  27.         
  28.         portion = <cardinal number>
  29.         
  30.     However, the implementation is not so ridged.
  31.     
  32.     To use, call MakePanes() passing the enclosure and the program. For example,
  33.     
  34.         thePane = new CPane;
  35.         thePane->IPane(...)
  36.         
  37.         MakePanes( thePane, "V 1 E 1 F 25 E 2 ." );
  38.         
  39.     This will enclose in thePane a CVAccordionPane with three sub-panes. The
  40.     first and thrid sub-panes are elastic while the second has a fixed with of
  41.     25 pixels. The first elastic sub-pane should be given 1/3 of the height
  42.     while the second elastic sub-pane 2/3 of the height.
  43.     
  44.     NOTE: All vertical and horizontal panes are elastic. This is a restriction 
  45.     of the parser and not the accordion classes.
  46.     
  47.     NOTE: There is almost no error checking.
  48.  
  49.     AUTHOR: Andrew_Gilmartin@Brown.Edu
  50.     REVISION: 1
  51.  
  52. ******************************************************************************/
  53.  
  54. #include "CAccordionPane.h"
  55. #include "Parser.h"
  56.  
  57.  
  58. void MakePanes( CPane* anEnclosure, char* program )
  59. {
  60.     MakeList( anEnclosure, SkipSpace( program ) );
  61.  
  62.     ((CPane*)(anEnclosure->itsSubviews->FirstItem()))->FitToEnclosure( TRUE, TRUE );
  63.  
  64. } /* MakePanes */
  65.  
  66.  
  67. char* MakeList( CPane* anEnclosure, char* program )
  68. {
  69.     while ( *program != '.' && *program != '\0' )
  70.     {
  71.         switch ( *program )
  72.         {
  73.             case 'V':
  74.                 program = MakeVertPane( anEnclosure, NextToken( program ) );
  75.                 break;
  76.                 
  77.             case 'H':
  78.                 program = MakeHorizPane( anEnclosure, NextToken( program ) );
  79.                 break;
  80.                 
  81.             case 'F':
  82.                 program = MakeFixedPane( anEnclosure, NextToken( program ) );
  83.                 break;
  84.                 
  85.             case 'E':
  86.                 program = MakeElasticPane( (CAccordionPane*) anEnclosure, NextToken( program ) );
  87.                 break;
  88.                 
  89.             default:
  90.                 Failure( -1, 0 );
  91.         }
  92.     }
  93.  
  94.     return NextToken( program );
  95.     
  96. } /* MakeList */
  97.  
  98.  
  99.  
  100. char* MakeVertPane( CPane* anEnclosure, char* program )
  101. {
  102.     CVAccordionPane* thePane;
  103.     
  104.     thePane = new CVAccordionPane;
  105.     thePane->IVAccordionPane
  106.         ( anEnclosure
  107.         , anEnclosure->itsSupervisor
  108.         , 0, 0 // size
  109.         , 0, 0 // offset
  110.         , sizELASTIC
  111.         , sizELASTIC );
  112.     thePane->SetWantsClicks( TRUE );
  113.  
  114.     return MakeList( thePane, NextToken( program ) );
  115.  
  116. } /* MakeVertPane */
  117.  
  118.  
  119. char* MakeHorizPane( CPane* anEnclosure, char* program )
  120. {
  121.     CHAccordionPane* thePane;
  122.     
  123.     thePane = new CHAccordionPane;
  124.     thePane->IHAccordionPane
  125.         ( anEnclosure
  126.         , anEnclosure->itsSupervisor
  127.         , 0, 0 // size
  128.         , 0, 0 // offset
  129.         , sizELASTIC
  130.         , sizELASTIC );
  131.     thePane->SetWantsClicks( TRUE );
  132.     
  133.     return MakeList( thePane, NextToken( program ) );
  134.  
  135. } /* MakeHorizPane */
  136.  
  137.  
  138. CPane* MakePane
  139.     ( CView* anEnclosure
  140.     , short aWidth
  141.     , short aHeight
  142.     , SizingOption hSizing
  143.     , SizingOption vSizing )
  144. {
  145. #if FALSE
  146.     CPane* thePane;
  147.     CPaneBorder* theBorder;
  148.     Rect kBorderMargin = { 1, 1, -1, -1 };
  149.     //Rect kBorderMargin = { 0, 0, 0, 0 };
  150.  
  151.     thePane = new CPane;
  152.     thePane->IPane
  153.         ( anEnclosure
  154.         , anEnclosure->itsSupervisor
  155.         , aWidth
  156.         , aHeight
  157.         , 0
  158.         , 0
  159.         , hSizing, vSizing );
  160.         
  161.     theBorder = new CPaneBorder;
  162.     theBorder->IPaneBorder( kBorderFrame );
  163.     theBorder->SetMargin( &kBorderMargin );
  164.     theBorder->SetPattern( gray );
  165.     thePane->SetBorder( theBorder );
  166.     
  167.     return thePane;
  168. #else
  169.     CScrollPane* theScrollPane;
  170.     CEditText* theEditPane;
  171.     CPaneBorder* theBorder;
  172.     Rect kBorderMargin = { 0, 0, 0, 0 };
  173.  
  174.     theScrollPane = new CScrollPane;
  175.     theScrollPane->IScrollPane
  176.         ( anEnclosure
  177.         , anEnclosure->itsSupervisor
  178.         , aWidth
  179.         , aHeight
  180.         , 0
  181.         , 0
  182.         , hSizing
  183.         , vSizing
  184.         , TRUE, TRUE, FALSE );
  185.  
  186.     theBorder = new CPaneBorder;
  187.     theBorder->IPaneBorder( kBorderTop + kBorderLeft );
  188.     theBorder->SetMargin( &kBorderMargin );
  189.     //theScrollPane->SetBorder( theBorder );
  190.  
  191.     theEditPane = new CEditText;
  192.     theEditPane->IEditText
  193.         ( theScrollPane
  194.         , theScrollPane->itsSupervisor
  195.         , 0
  196.         , 0
  197.         , 0
  198.         , 0
  199.         , sizELASTIC
  200.         , sizELASTIC
  201.         , 0 );
  202.     theEditPane->FitToEnclosure( TRUE, TRUE );
  203.     theScrollPane->InstallPanorama( theEditPane );
  204.  
  205.     return theScrollPane;
  206. #endif
  207.  
  208. } /* MakePane */
  209.  
  210.  
  211. char* MakeFixedPane( CView* anEnclosure, char* program )
  212. {
  213.     short size = NumberFromStream( program );
  214.  
  215.     if ( member( anEnclosure, CVAccordionPane ) )
  216.     {
  217.         MakePane
  218.             ( anEnclosure
  219.             , 0 // width
  220.             , size // height
  221.             , sizELASTIC
  222.             , sizFIXEDSTICKY );
  223.     }
  224.     else
  225.     {
  226.         MakePane
  227.             ( anEnclosure
  228.             , size // width
  229.             , 0 // height
  230.             , sizFIXEDSTICKY
  231.             , sizELASTIC );
  232.     }
  233.  
  234.     return NextToken( program );
  235.     
  236. } /* MakeFixedPane */
  237.  
  238.  
  239. char* MakeElasticPane( CAccordionPane* anEnclosure, char* program )
  240. {
  241.     CPane* thePane = MakePane
  242.         ( anEnclosure
  243.         , 0 // width
  244.         , 0 // height
  245.         , sizELASTIC
  246.         , sizELASTIC );
  247.  
  248.     anEnclosure->SetSubviewPortion( thePane, NumberFromStream( program ), FALSE );
  249.  
  250.     return NextToken( program );
  251.     
  252. } /* MakeElasticPane */
  253.  
  254.  
  255.  
  256. short NumberFromStream( char* stream )
  257. {
  258.     short number = 0;
  259.     
  260.     while ( '0' <= *stream && *stream <= '9' )
  261.     {
  262.         number = number * 10 + ( *stream - '0' );
  263.         stream++;
  264.     }
  265.     
  266.     return number;
  267.  
  268. } /* NumberFromStream */
  269.  
  270.  
  271. char* SkipSpace( char* stream )
  272. {
  273.     while ( *stream == ' ' || *stream == '\r' || *stream == '\t' )
  274.         stream++;
  275.         
  276.     return stream;
  277.  
  278. } /* SkipSpace */
  279.  
  280.  
  281. char* SkipToken( char* stream )
  282. {
  283.     while ( *stream != ' ' && *stream != '\r' && *stream != '\t' && *stream != '\0' )
  284.         stream++;
  285.  
  286.     return stream;
  287.  
  288. } /* SkipToken */
  289.  
  290.  
  291. char* NextToken( char* stream )
  292. {
  293.     return SkipSpace( SkipToken( stream ) );
  294.     
  295. } /* NextToken */
  296.  
  297.  
  298.  
  299.  
  300.